{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install supervision ultralytics opencv-python\n",
        "!pip install --upgrade supervision\n",
        "\n",
        "import cv2\n",
        "import numpy as np\n",
        "import supervision as sv\n",
        "from ultralytics import YOLO\n",
        "import matplotlib.pyplot as plt\n",
        "from collections import defaultdict\n",
        "\n",
        "model = YOLO('yolov8n.pt')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gxVOnHsjugJ3",
        "outputId": "85e3326a-73c8-4d1f-96b6-a83304c67527"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: supervision in /usr/local/lib/python3.11/dist-packages (0.26.1)\n",
            "Requirement already satisfied: ultralytics in /usr/local/lib/python3.11/dist-packages (8.3.170)\n",
            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.11/dist-packages (4.12.0.88)\n",
            "Requirement already satisfied: numpy>=1.21.2 in /usr/local/lib/python3.11/dist-packages (from supervision) (2.0.2)\n",
            "Requirement already satisfied: scipy>=1.10.0 in /usr/local/lib/python3.11/dist-packages (from supervision) (1.16.0)\n",
            "Requirement already satisfied: matplotlib>=3.6.0 in /usr/local/lib/python3.11/dist-packages (from supervision) (3.10.0)\n",
            "Requirement already satisfied: pyyaml>=5.3 in /usr/local/lib/python3.11/dist-packages (from supervision) (6.0.2)\n",
            "Requirement already satisfied: defusedxml>=0.7.1 in /usr/local/lib/python3.11/dist-packages (from supervision) (0.7.1)\n",
            "Requirement already satisfied: pillow>=9.4 in /usr/local/lib/python3.11/dist-packages (from supervision) (11.3.0)\n",
            "Requirement already satisfied: requests>=2.26.0 in /usr/local/lib/python3.11/dist-packages (from supervision) (2.32.3)\n",
            "Requirement already satisfied: tqdm>=4.62.3 in /usr/local/lib/python3.11/dist-packages (from supervision) (4.67.1)\n",
            "Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (2.6.0+cu124)\n",
            "Requirement already satisfied: torchvision>=0.9.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (0.21.0+cu124)\n",
            "Requirement already satisfied: psutil in /usr/local/lib/python3.11/dist-packages (from ultralytics) (5.9.5)\n",
            "Requirement already satisfied: py-cpuinfo in /usr/local/lib/python3.11/dist-packages (from ultralytics) (9.0.0)\n",
            "Requirement already satisfied: pandas>=1.1.4 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (2.2.2)\n",
            "Requirement already satisfied: ultralytics-thop>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (2.0.14)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (1.3.2)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (4.59.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (1.4.8)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (25.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (3.2.3)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (2.9.0.post0)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.1.4->ultralytics) (2025.2)\n",
            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.1.4->ultralytics) (2025.2)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (3.4.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (2.5.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (2025.7.14)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.18.0)\n",
            "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (4.14.1)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.5)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.1.6)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (2025.3.0)\n",
            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.4.127)\n",
            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.4.127)\n",
            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.4.127)\n",
            "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (9.1.0.70)\n",
            "Requirement already satisfied: nvidia-cublas-cu12==12.4.5.8 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.4.5.8)\n",
            "Requirement already satisfied: nvidia-cufft-cu12==11.2.1.3 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (11.2.1.3)\n",
            "Requirement already satisfied: nvidia-curand-cu12==10.3.5.147 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (10.3.5.147)\n",
            "Requirement already satisfied: nvidia-cusolver-cu12==11.6.1.9 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (11.6.1.9)\n",
            "Requirement already satisfied: nvidia-cusparse-cu12==12.3.1.170 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.3.1.170)\n",
            "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (0.6.2)\n",
            "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (2.21.5)\n",
            "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.4.127)\n",
            "Requirement already satisfied: nvidia-nvjitlink-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.4.127)\n",
            "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.2.0)\n",
            "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (1.13.1)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch>=1.8.0->ultralytics) (1.3.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib>=3.6.0->supervision) (1.17.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch>=1.8.0->ultralytics) (3.0.2)\n",
            "Requirement already satisfied: supervision in /usr/local/lib/python3.11/dist-packages (0.26.1)\n",
            "Requirement already satisfied: numpy>=1.21.2 in /usr/local/lib/python3.11/dist-packages (from supervision) (2.0.2)\n",
            "Requirement already satisfied: scipy>=1.10.0 in /usr/local/lib/python3.11/dist-packages (from supervision) (1.16.0)\n",
            "Requirement already satisfied: matplotlib>=3.6.0 in /usr/local/lib/python3.11/dist-packages (from supervision) (3.10.0)\n",
            "Requirement already satisfied: pyyaml>=5.3 in /usr/local/lib/python3.11/dist-packages (from supervision) (6.0.2)\n",
            "Requirement already satisfied: defusedxml>=0.7.1 in /usr/local/lib/python3.11/dist-packages (from supervision) (0.7.1)\n",
            "Requirement already satisfied: pillow>=9.4 in /usr/local/lib/python3.11/dist-packages (from supervision) (11.3.0)\n",
            "Requirement already satisfied: requests>=2.26.0 in /usr/local/lib/python3.11/dist-packages (from supervision) (2.32.3)\n",
            "Requirement already satisfied: tqdm>=4.62.3 in /usr/local/lib/python3.11/dist-packages (from supervision) (4.67.1)\n",
            "Requirement already satisfied: opencv-python>=4.5.5.64 in /usr/local/lib/python3.11/dist-packages (from supervision) (4.12.0.88)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (1.3.2)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (4.59.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (1.4.8)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (25.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (3.2.3)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6.0->supervision) (2.9.0.post0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (3.4.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (2.5.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.26.0->supervision) (2025.7.14)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib>=3.6.0->supervision) (1.17.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "    tracker = sv.ByteTrack()\n",
        "except AttributeError:\n",
        "    try:\n",
        "        tracker = sv.ByteTracker()\n",
        "    except AttributeError:\n",
        "        print(\"Using basic tracking - install latest supervision for advanced tracking\")\n",
        "        tracker = None\n",
        "\n",
        "try:\n",
        "    smoother = sv.DetectionsSmoother(length=5)\n",
        "except AttributeError:\n",
        "    smoother = None\n",
        "    print(\"DetectionsSmoother not available in this version\")\n",
        "\n",
        "try:\n",
        "    box_annotator = sv.BoundingBoxAnnotator(thickness=2)\n",
        "    label_annotator = sv.LabelAnnotator()\n",
        "    if hasattr(sv, 'TraceAnnotator'):\n",
        "        trace_annotator = sv.TraceAnnotator(thickness=2, trace_length=30)\n",
        "    else:\n",
        "        trace_annotator = None\n",
        "except AttributeError:\n",
        "    try:\n",
        "        box_annotator = sv.BoxAnnotator(thickness=2)\n",
        "        label_annotator = sv.LabelAnnotator()\n",
        "        trace_annotator = None\n",
        "    except AttributeError:\n",
        "        print(\"Using basic annotators - some features may be limited\")\n",
        "        box_annotator = None\n",
        "        label_annotator = None\n",
        "        trace_annotator = None\n",
        "\n",
        "def create_zones(frame_shape):\n",
        "    h, w = frame_shape[:2]\n",
        "\n",
        "    try:\n",
        "        entry_zone = sv.PolygonZone(\n",
        "            polygon=np.array([[0, h//3], [w//3, h//3], [w//3, 2*h//3], [0, 2*h//3]]),\n",
        "            frame_resolution_wh=(w, h)\n",
        "        )\n",
        "\n",
        "        exit_zone = sv.PolygonZone(\n",
        "            polygon=np.array([[2*w//3, h//3], [w, h//3], [w, 2*h//3], [2*w//3, 2*h//3]]),\n",
        "            frame_resolution_wh=(w, h)\n",
        "        )\n",
        "    except TypeError:\n",
        "        entry_zone = sv.PolygonZone(\n",
        "            polygon=np.array([[0, h//3], [w//3, h//3], [w//3, 2*h//3], [0, 2*h//3]])\n",
        "        )\n",
        "        exit_zone = sv.PolygonZone(\n",
        "            polygon=np.array([[2*w//3, h//3], [w, h//3], [w, 2*h//3], [2*w//3, 2*h//3]])\n",
        "        )\n",
        "\n",
        "    return entry_zone, exit_zone"
      ],
      "metadata": {
        "id": "j_w13927usHZ"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class AdvancedAnalytics:\n",
        "    def __init__(self):\n",
        "        self.track_history = defaultdict(list)\n",
        "        self.zone_crossings = {\"entry\": 0, \"exit\": 0}\n",
        "        self.speed_data = defaultdict(list)\n",
        "\n",
        "    def update_tracking(self, detections):\n",
        "        if hasattr(detections, 'tracker_id') and detections.tracker_id is not None:\n",
        "            for i in range(len(detections)):\n",
        "                track_id = detections.tracker_id[i]\n",
        "                if track_id is not None:\n",
        "                    bbox = detections.xyxy[i]\n",
        "                    center = np.array([(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2])\n",
        "                    self.track_history[track_id].append(center)\n",
        "\n",
        "                    if len(self.track_history[track_id]) >= 2:\n",
        "                        prev_pos = self.track_history[track_id][-2]\n",
        "                        curr_pos = self.track_history[track_id][-1]\n",
        "                        speed = np.linalg.norm(curr_pos - prev_pos)\n",
        "                        self.speed_data[track_id].append(speed)\n",
        "\n",
        "    def get_statistics(self):\n",
        "        total_tracks = len(self.track_history)\n",
        "        avg_speed = np.mean([np.mean(speeds) for speeds in self.speed_data.values() if speeds])\n",
        "        return {\n",
        "            \"total_objects\": total_tracks,\n",
        "            \"zone_entries\": self.zone_crossings[\"entry\"],\n",
        "            \"zone_exits\": self.zone_crossings[\"exit\"],\n",
        "            \"avg_speed\": avg_speed if not np.isnan(avg_speed) else 0\n",
        "        }\n",
        "\n",
        "def process_video(source=0, max_frames=300):\n",
        "    \"\"\"\n",
        "    Process video source with advanced supervision features\n",
        "    source: video path or 0 for webcam\n",
        "    max_frames: limit processing for demo\n",
        "    \"\"\"\n",
        "    cap = cv2.VideoCapture(source)\n",
        "    analytics = AdvancedAnalytics()\n",
        "\n",
        "    ret, frame = cap.read()\n",
        "    if not ret:\n",
        "        print(\"Failed to read video source\")\n",
        "        return\n",
        "\n",
        "    entry_zone, exit_zone = create_zones(frame.shape)\n",
        "\n",
        "    try:\n",
        "        entry_zone_annotator = sv.PolygonZoneAnnotator(\n",
        "            zone=entry_zone,\n",
        "            color=sv.Color.GREEN,\n",
        "            thickness=2\n",
        "        )\n",
        "        exit_zone_annotator = sv.PolygonZoneAnnotator(\n",
        "            zone=exit_zone,\n",
        "            color=sv.Color.RED,\n",
        "            thickness=2\n",
        "        )\n",
        "    except (AttributeError, TypeError):\n",
        "        entry_zone_annotator = sv.PolygonZoneAnnotator(zone=entry_zone)\n",
        "        exit_zone_annotator = sv.PolygonZoneAnnotator(zone=exit_zone)\n",
        "\n",
        "    frame_count = 0\n",
        "    results_frames = []\n",
        "\n",
        "    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)\n",
        "\n",
        "    while ret and frame_count < max_frames:\n",
        "        ret, frame = cap.read()\n",
        "        if not ret:\n",
        "            break\n",
        "\n",
        "        results = model(frame, verbose=False)[0]\n",
        "        detections = sv.Detections.from_ultralytics(results)\n",
        "\n",
        "        detections = detections[detections.class_id == 0]\n",
        "\n",
        "        if tracker is not None:\n",
        "            detections = tracker.update_with_detections(detections)\n",
        "\n",
        "        if smoother is not None:\n",
        "            detections = smoother.update_with_detections(detections)\n",
        "\n",
        "        analytics.update_tracking(detections)\n",
        "\n",
        "        entry_zone.trigger(detections)\n",
        "        exit_zone.trigger(detections)\n",
        "\n",
        "        labels = []\n",
        "        for i in range(len(detections)):\n",
        "            confidence = detections.confidence[i] if detections.confidence is not None else 0.0\n",
        "\n",
        "            if hasattr(detections, 'tracker_id') and detections.tracker_id is not None:\n",
        "                track_id = detections.tracker_id[i]\n",
        "                if track_id is not None:\n",
        "                    speed = analytics.speed_data[track_id][-1] if analytics.speed_data[track_id] else 0\n",
        "                    label = f\"ID:{track_id} | Conf:{confidence:.2f} | Speed:{speed:.1f}\"\n",
        "                else:\n",
        "                    label = f\"Conf:{confidence:.2f}\"\n",
        "            else:\n",
        "                label = f\"Conf:{confidence:.2f}\"\n",
        "            labels.append(label)\n",
        "\n",
        "        annotated_frame = frame.copy()\n",
        "\n",
        "        annotated_frame = entry_zone_annotator.annotate(annotated_frame)\n",
        "        annotated_frame = exit_zone_annotator.annotate(annotated_frame)\n",
        "\n",
        "        if trace_annotator is not None:\n",
        "            annotated_frame = trace_annotator.annotate(annotated_frame, detections)\n",
        "\n",
        "        if box_annotator is not None:\n",
        "            annotated_frame = box_annotator.annotate(annotated_frame, detections)\n",
        "        else:\n",
        "            for i in range(len(detections)):\n",
        "                bbox = detections.xyxy[i].astype(int)\n",
        "                cv2.rectangle(annotated_frame, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)\n",
        "\n",
        "        if label_annotator is not None:\n",
        "            annotated_frame = label_annotator.annotate(annotated_frame, detections, labels)\n",
        "        else:\n",
        "            for i, label in enumerate(labels):\n",
        "                if i < len(detections):\n",
        "                    bbox = detections.xyxy[i].astype(int)\n",
        "                    cv2.putText(annotated_frame, label, (bbox[0], bbox[1]-10),\n",
        "                               cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)\n",
        "\n",
        "        stats = analytics.get_statistics()\n",
        "        y_offset = 30\n",
        "        for key, value in stats.items():\n",
        "            text = f\"{key.replace('_', ' ').title()}: {value:.1f}\"\n",
        "            cv2.putText(annotated_frame, text, (10, y_offset),\n",
        "                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)\n",
        "            y_offset += 30\n",
        "\n",
        "        if frame_count % 30 == 0:\n",
        "            results_frames.append(cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB))\n",
        "\n",
        "        frame_count += 1\n",
        "\n",
        "        if frame_count % 50 == 0:\n",
        "            print(f\"Processed {frame_count} frames...\")\n",
        "\n",
        "    cap.release()\n",
        "\n",
        "    if results_frames:\n",
        "        fig, axes = plt.subplots(2, 2, figsize=(15, 10))\n",
        "        axes = axes.flatten()\n",
        "\n",
        "        for i, (ax, frame) in enumerate(zip(axes, results_frames[:4])):\n",
        "            ax.imshow(frame)\n",
        "            ax.set_title(f\"Frame {i*30}\")\n",
        "            ax.axis('off')\n",
        "\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "    final_stats = analytics.get_statistics()\n",
        "    print(\"\\n=== FINAL ANALYTICS ===\")\n",
        "    for key, value in final_stats.items():\n",
        "        print(f\"{key.replace('_', ' ').title()}: {value:.2f}\")\n",
        "\n",
        "    return analytics\n",
        "\n",
        "print(\"Starting advanced supervision demo...\")\n",
        "print(\"Features: Object detection, tracking, zones, speed analysis, smoothing\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H8N-Fuh6u9ie",
        "outputId": "8d43052e-c161-4c40-f251-2925345f009f"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting advanced supervision demo...\n",
            "Features: Object detection, tracking, zones, speed analysis, smoothing\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "owIvKghVsR1B",
        "outputId": "0bc9af23-a499-4e44-df73-191ed7ced254"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processed 50 frames...\n",
            "Processed 100 frames...\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1000 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=== FINAL ANALYTICS ===\n",
            "Total Objects: 0.00\n",
            "Zone Entries: 0.00\n",
            "Zone Exits: 0.00\n",
            "Avg Speed: 0.00\n",
            "\n",
            "Tutorial completed! Key features demonstrated:\n",
            "✓ YOLO integration with Supervision\n",
            "✓ Multi-object tracking with ByteTracker\n",
            "✓ Detection smoothing\n",
            "✓ Polygon zones for area monitoring\n",
            "✓ Advanced annotations (boxes, labels, traces)\n",
            "✓ Real-time analytics and statistics\n",
            "✓ Speed calculation and tracking history\n"
          ]
        }
      ],
      "source": [
        "def create_demo_video():\n",
        "    \"\"\"Create a simple demo video with moving objects\"\"\"\n",
        "    fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n",
        "    out = cv2.VideoWriter('demo.mp4', fourcc, 20.0, (640, 480))\n",
        "\n",
        "    for i in range(100):\n",
        "        frame = np.zeros((480, 640, 3), dtype=np.uint8)\n",
        "\n",
        "        x1 = int(50 + i * 2)\n",
        "        y1 = 200\n",
        "        x2 = int(100 + i * 1.5)\n",
        "        y2 = 250\n",
        "\n",
        "        cv2.rectangle(frame, (x1, y1), (x1+50, y1+50), (0, 255, 0), -1)\n",
        "        cv2.rectangle(frame, (x2, y2), (x2+50, y2+50), (255, 0, 0), -1)\n",
        "\n",
        "        out.write(frame)\n",
        "\n",
        "    out.release()\n",
        "    return 'demo.mp4'\n",
        "\n",
        "demo_video = create_demo_video()\n",
        "analytics = process_video(demo_video, max_frames=100)\n",
        "\n",
        "print(\"\\nTutorial completed! Key features demonstrated:\")\n",
        "print(\"✓ YOLO integration with Supervision\")\n",
        "print(\"✓ Multi-object tracking with ByteTracker\")\n",
        "print(\"✓ Detection smoothing\")\n",
        "print(\"✓ Polygon zones for area monitoring\")\n",
        "print(\"✓ Advanced annotations (boxes, labels, traces)\")\n",
        "print(\"✓ Real-time analytics and statistics\")\n",
        "print(\"✓ Speed calculation and tracking history\")"
      ]
    }
  ]
}